import random  # used for generating large scale test cases

# imports
import pytest  # used for our unit tests
from workload import AlexNet

# unit tests

# -------------------------------
# Basic Test Cases
# -------------------------------

def test_classify_single_zero():
    """Test with a single zero input."""
    net = AlexNet(num_classes=10)
    codeflash_output = net._classify([0]); result = codeflash_output # 1.39μs -> 1.20μs (15.8% faster)

def test_classify_single_positive():
    """Test with a single positive integer."""
    net = AlexNet(num_classes=10)
    codeflash_output = net._classify([7]); result = codeflash_output # 1.33μs -> 1.06μs (25.4% faster)

def test_classify_single_negative():
    """Test with a single negative integer."""
    net = AlexNet(num_classes=10)
    codeflash_output = net._classify([-3]); result = codeflash_output # 1.33μs -> 1.05μs (26.6% faster)

def test_classify_multiple_positives():
    """Test with multiple positive integers."""
    net = AlexNet(num_classes=10)
    codeflash_output = net._classify([1, 2, 3]); result = codeflash_output # 1.48μs -> 1.09μs (35.7% faster)

def test_classify_mixed_signs():
    """Test with both positive and negative numbers."""
    net = AlexNet(num_classes=10)
    codeflash_output = net._classify([5, -2, 8]); result = codeflash_output # 1.45μs -> 1.07μs (35.3% faster)

def test_classify_all_zeros():
    """Test with all zeros."""
    net = AlexNet(num_classes=5)
    codeflash_output = net._classify([0, 0, 0, 0]); result = codeflash_output # 1.54μs -> 1.09μs (41.3% faster)

def test_classify_empty_input():
    """Test with empty input list."""
    net = AlexNet(num_classes=10)
    codeflash_output = net._classify([]); result = codeflash_output # 1.01μs -> 1.05μs (3.80% slower)


# -------------------------------
# Edge Test Cases
# -------------------------------

def test_classify_large_positive_numbers():
    """Test with very large positive numbers."""
    net = AlexNet(num_classes=100)
    features = [10**12, 10**13, 10**14]
    total = sum(features)
    expected = [total % 100] * 3
    codeflash_output = net._classify(features) # 1.44μs -> 852ns (69.2% faster)

def test_classify_large_negative_numbers():
    """Test with very large negative numbers."""
    net = AlexNet(num_classes=100)
    features = [-10**12, -10**13, -10**14]
    total = sum(features)
    expected = [total % 100] * 3
    codeflash_output = net._classify(features) # 1.39μs -> 791ns (76.1% faster)

def test_classify_num_classes_one():
    """Test with num_classes = 1 (all outputs should be zero)."""
    net = AlexNet(num_classes=1)
    features = [1, 2, 3, 4, 5]
    codeflash_output = net._classify(features) # 1.69μs -> 1.08μs (56.5% faster)

def test_classify_num_classes_large_prime():
    """Test with a large prime number for num_classes."""
    net = AlexNet(num_classes=997)
    features = [100, 200, 300]
    total = 600
    expected = [600 % 997] * 3
    codeflash_output = net._classify(features) # 1.52μs -> 982ns (55.0% faster)

def test_classify_negative_and_zero_classes():
    """Test with negative and zero features and num_classes > 1."""
    net = AlexNet(num_classes=7)
    features = [0, -7, 7, -14]
    total = sum(features)  # -14
    expected = [(-14) % 7] * 4  # (-14) % 7 == 0
    codeflash_output = net._classify(features) # 1.52μs -> 881ns (72.9% faster)

def test_classify_single_element_large_num_classes():
    """Test with a single element and a large num_classes."""
    net = AlexNet(num_classes=10**6)
    features = [123456]
    expected = [123456 % 10**6]
    codeflash_output = net._classify(features) # 1.37μs -> 1.02μs (34.3% faster)

def test_classify_sum_exactly_divisible():
    """Test where sum is exactly divisible by num_classes."""
    net = AlexNet(num_classes=15)
    features = [5, 5, 5]
    total = 15
    expected = [0, 0, 0]
    codeflash_output = net._classify(features) # 1.46μs -> 1.08μs (35.2% faster)

def test_classify_sum_negative_modulo():
    """Test where sum is negative and not divisible by num_classes."""
    net = AlexNet(num_classes=8)
    features = [-3, -5, -10]
    total = -18
    expected = [(-18) % 8] * 3  # (-18) % 8 == 6
    codeflash_output = net._classify(features) # 1.60μs -> 972ns (64.9% faster)

def test_classify_non_integer_features():
    """Test with float features."""
    net = AlexNet(num_classes=10)
    features = [1.5, 2.5, 3.0]
    total = sum(features)  # 7.0
    expected = [7.0 % 10] * 3
    codeflash_output = net._classify(features) # 1.82μs -> 1.13μs (61.0% faster)

def test_classify_empty_num_classes_zero():
    """Test with num_classes=0 should raise ZeroDivisionError."""
    net = AlexNet(num_classes=0)
    with pytest.raises(ZeroDivisionError):
        net._classify([1, 2, 3])


# -------------------------------
# Large Scale Test Cases
# -------------------------------

def test_classify_large_input_list():
    """Test with a large input list (length 1000)."""
    net = AlexNet(num_classes=100)
    features = [i for i in range(1000)]
    total = sum(features)
    expected = [total % 100] * 1000
    codeflash_output = net._classify(features) # 41.2μs -> 5.64μs (631% faster)

def test_classify_large_random_input():
    """Test with a large random input list."""
    net = AlexNet(num_classes=500)
    random.seed(42)  # Deterministic test
    features = [random.randint(-1000, 1000) for _ in range(999)]
    total = sum(features)
    expected = [total % 500] * 999
    codeflash_output = net._classify(features) # 44.7μs -> 8.86μs (404% faster)

def test_classify_large_input_all_same():
    """Test with a large input list where all elements are the same."""
    net = AlexNet(num_classes=77)
    features = [42] * 1000
    total = sum(features)
    expected = [total % 77] * 1000
    codeflash_output = net._classify(features) # 41.2μs -> 5.42μs (660% faster)

def test_classify_large_input_all_negatives():
    """Test with a large input list of all negative numbers."""
    net = AlexNet(num_classes=101)
    features = [-5] * 1000
    total = sum(features)
    expected = [total % 101] * 1000
    codeflash_output = net._classify(features) # 41.4μs -> 6.05μs (585% faster)

def test_classify_large_input_floats():
    """Test with a large input list of floats."""
    net = AlexNet(num_classes=123)
    features = [float(i) for i in range(1000)]
    total = sum(features)
    expected = [total % 123] * 1000
    codeflash_output = net._classify(features) # 60.2μs -> 5.43μs (1009% faster)

def test_classify_large_input_with_zeros():
    """Test with a large input list containing zeros and positives."""
    net = AlexNet(num_classes=50)
    features = [0 if i % 2 == 0 else i for i in range(1000)]
    total = sum(features)
    expected = [total % 50] * 1000
    codeflash_output = net._classify(features) # 40.9μs -> 5.50μs (643% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import random  # used for generating large scale test data

# imports
import pytest  # used for our unit tests
from workload import AlexNet

# unit tests

# ------------------------
# BASIC TEST CASES
# ------------------------

def test_empty_features_returns_empty_list():
    # Test with empty input
    model = AlexNet(num_classes=10)
    codeflash_output = model._classify([]) # 1.14μs -> 1.17μs (2.64% slower)

def test_single_element_feature():
    # Test with a single-element feature list
    model = AlexNet(num_classes=10)
    codeflash_output = model._classify([7]) # 1.40μs -> 1.12μs (25.0% faster)

def test_multiple_positive_integers():
    # Test with multiple positive integers
    model = AlexNet(num_classes=10)
    features = [1, 2, 3, 4]
    expected = [sum(features) % 10] * len(features)
    codeflash_output = model._classify(features) # 1.32μs -> 741ns (78.5% faster)

def test_multiple_negative_integers():
    # Test with multiple negative integers
    model = AlexNet(num_classes=10)
    features = [-1, -2, -3, -4]
    expected = [sum(features) % 10] * len(features)
    codeflash_output = model._classify(features) # 1.48μs -> 762ns (94.6% faster)

def test_mixed_positive_and_negative():
    # Test with a mix of positive and negative integers
    model = AlexNet(num_classes=10)
    features = [5, -3, 7, -2]
    expected = [sum(features) % 10] * len(features)
    codeflash_output = model._classify(features) # 1.37μs -> 742ns (84.9% faster)

def test_sum_divisible_by_num_classes():
    # Test where sum(features) is exactly divisible by num_classes
    model = AlexNet(num_classes=6)
    features = [2, 2, 2]
    expected = [0] * 3
    codeflash_output = model._classify(features) # 1.44μs -> 941ns (53.2% faster)

def test_sum_less_than_zero():
    # Test where sum(features) is negative
    model = AlexNet(num_classes=7)
    features = [-3, -4]
    expected = [sum(features) % 7] * 2
    codeflash_output = model._classify(features) # 1.25μs -> 761ns (64.5% faster)

def test_sum_equals_zero():
    # Test where sum(features) is zero
    model = AlexNet(num_classes=5)
    features = [2, -2, 0]
    expected = [0] * 3
    codeflash_output = model._classify(features) # 1.60μs -> 1.09μs (46.8% faster)

def test_non_default_num_classes():
    # Test with a non-default num_classes value
    model = AlexNet(num_classes=3)
    features = [1, 2, 3]
    expected = [sum(features) % 3] * 3
    codeflash_output = model._classify(features) # 1.25μs -> 761ns (64.7% faster)

# ------------------------
# EDGE TEST CASES
# ------------------------

def test_large_positive_numbers():
    # Test with very large positive integers
    model = AlexNet(num_classes=100000)
    features = [10**12, 10**12, 10**12]
    expected = [sum(features) % 100000] * 3
    codeflash_output = model._classify(features) # 1.43μs -> 831ns (72.4% faster)

def test_large_negative_numbers():
    # Test with very large negative integers
    model = AlexNet(num_classes=100000)
    features = [-10**12, -10**12, -10**12]
    expected = [sum(features) % 100000] * 3
    codeflash_output = model._classify(features) # 1.36μs -> 831ns (63.9% faster)

def test_zero_num_classes_raises_zero_division():
    # Test with num_classes = 0 should raise ZeroDivisionError
    model = AlexNet(num_classes=0)
    features = [1, 2, 3]
    with pytest.raises(ZeroDivisionError):
        model._classify(features)

def test_features_with_zeros():
    # Test with features containing zeros
    model = AlexNet(num_classes=10)
    features = [0, 0, 0]
    expected = [0, 0, 0]
    codeflash_output = model._classify(features) # 1.63μs -> 1.22μs (33.5% faster)

def test_features_all_same_value():
    # Test with features all having the same value
    model = AlexNet(num_classes=5)
    features = [4, 4, 4, 4]
    expected = [sum(features) % 5] * 4
    codeflash_output = model._classify(features) # 1.29μs -> 761ns (69.9% faster)

def test_features_with_min_and_max_integers():
    # Test with Python's min and max integer values
    model = AlexNet(num_classes=1000)
    features = [-(2**63), 2**63-1]  # Simulate 64-bit min/max
    expected = [sum(features) % 1000] * 2
    codeflash_output = model._classify(features) # 1.21μs -> 811ns (49.6% faster)

def test_non_integer_features():
    # Test with float features (should work, as sum() and % are defined for floats and ints)
    model = AlexNet(num_classes=10)
    features = [1.5, 2.5, -1.0]
    expected = [sum(features) % 10] * 3
    codeflash_output = model._classify(features) # 1.58μs -> 1.00μs (58.0% faster)

def test_features_with_boolean_values():
    # Test with boolean values (True==1, False==0)
    model = AlexNet(num_classes=2)
    features = [True, False, True]
    expected = [sum(features) % 2] * 3
    codeflash_output = model._classify(features) # 1.29μs -> 812ns (59.1% faster)

def test_features_is_tuple():
    # Test with features as a tuple, not a list
    model = AlexNet(num_classes=10)
    features = (1, 2, 3)
    expected = [sum(features) % 10] * 3
    codeflash_output = model._classify(features) # 1.23μs -> 792ns (55.6% faster)


def test_large_feature_list_all_ones():
    # Test with a large feature list of all ones
    model = AlexNet(num_classes=100)
    features = [1] * 1000
    expected = [sum(features) % 100] * 1000
    codeflash_output = model._classify(features) # 41.2μs -> 5.65μs (628% faster)

def test_large_feature_list_random_integers():
    # Test with a large feature list of random integers
    model = AlexNet(num_classes=500)
    features = [random.randint(-1000, 1000) for _ in range(1000)]
    expected_value = sum(features) % 500
    codeflash_output = model._classify(features); result = codeflash_output # 52.7μs -> 9.28μs (468% faster)

def test_large_feature_list_mixed_types():
    # Test with a large feature list containing ints, floats, and bools
    model = AlexNet(num_classes=123)
    features = [random.choice([1, 2.5, True, False, -3, 0.0]) for _ in range(1000)]
    expected_value = sum(features) % 123
    codeflash_output = model._classify(features); result = codeflash_output # 53.9μs -> 11.2μs (382% faster)

def test_large_feature_list_sum_is_zero():
    # Test with a large feature list where sum is zero
    model = AlexNet(num_classes=77)
    features = [1] * 500 + [-1] * 500
    expected = [0] * 1000
    codeflash_output = model._classify(features) # 38.4μs -> 6.35μs (505% faster)

def test_large_feature_list_sum_is_negative():
    # Test with a large feature list where sum is negative
    model = AlexNet(num_classes=321)
    features = [-2] * 600 + [1] * 400
    expected_value = sum(features) % 321
    codeflash_output = model._classify(features); result = codeflash_output # 41.8μs -> 5.83μs (617% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.